//#include"MyIconEngine.h"

//#ifndef QT_NO_SVGRENDERER


////#include<QGuiApplication>
////#include <private/qguiapplication_p.h>
/////usr/include/x86_64-linux-gnu/qt5/QtGui/5.15.10/QtGui/private
////#include<QtGui/QAbstractTextDocumentLayout>

////#include<QtGui/5.15.10/QtGui/private/qguiapplication_p.h>

//#include<QIconEngine>

//#include "qpainter.h"
//#include "qpixmap.h"
//#include "qsvgrenderer.h"
//#include "qpixmapcache.h"
//#include "qfileinfo.h"
//#include <qmimedatabase.h>
//#include <qmimetype.h>
//#include <QAtomicInt>
//#include "qdebug.h"
////#include <private/qguiapplication_p.h>

////#include <QCoreApplication>

//QT_BEGIN_NAMESPACE
//class QSvgIconEnginePrivate : public QSharedData
//{
//public:
//    QSvgIconEnginePrivate() : svgBuffers(0), addedPixmaps(0)
//    {
//        stepSerialNum();
//    }
//    ~QSvgIconEnginePrivate()
//    {
//        delete addedPixmaps;
//        delete svgBuffers;
//    }
//    static int hashKey(QIcon::Mode mode, QIcon::State state)
//    {
//        return (((mode)<<4)|state);
//    }
//    QString pmcKey(const QSize &size, QIcon::Mode mode, QIcon::State state)
//    {
//        return QLatin1String("$qt_svgicon_")
//                 + QString::number(serialNum, 16).append(QLatin1Char('_'))
//                 + QString::number((((((qint64(size.width()) << 11) | size.height()) << 11) | mode) << 4) | state, 16);
//    }
//    void stepSerialNum()
//    {
//        serialNum = lastSerialNum.fetchAndAddRelaxed(1);
//    }

//    bool tryLoad(QSvgRenderer *renderer, QIcon::Mode mode, QIcon::State state);

//    QIcon::Mode loadDataForModeAndState(QSvgRenderer *renderer, QIcon::Mode mode, QIcon::State state);

//    QHash<int, QString> svgFiles;
//    QHash<int, QByteArray> *svgBuffers;
//    QHash<int, QPixmap> *addedPixmaps;

//    int serialNum;
//    static QAtomicInt lastSerialNum;

//};
//QAtomicInt QSvgIconEnginePrivate::lastSerialNum;

//QSvgIconEngine::QSvgIconEngine()
//    : d(new QSvgIconEnginePrivate)
//{
//}

//QSvgIconEngine::QSvgIconEngine(const QSvgIconEngine &other)
//    : QIconEngine(other), d(new QSvgIconEnginePrivate)
//{
//    d->svgFiles = other.d->svgFiles;
//    if (other.d->svgBuffers)
//        d->svgBuffers = new QHash<int, QByteArray>(*other.d->svgBuffers);
//    if (other.d->addedPixmaps)
//        d->addedPixmaps = new QHash<int, QPixmap>(*other.d->addedPixmaps);
//}

//QSvgIconEngine::~QSvgIconEngine()
//{
//}

//QSize QSvgIconEngine::actualSize(const QSize &size, QIcon::Mode mode, QIcon::State state)
//{
//    if (d->addedPixmaps)
//    {
//        QPixmap pm = d->addedPixmaps->value(d->hashKey(mode, state));
//        if (!pm.isNull() && pm.size() == size)
//            return size;
//    }
//    QPixmap pm = pixmap(size, mode, state);
//    if (pm.isNull())
//        return QSize();
//    return pm.size();
//}
//static QByteArray maybeUncompress(const QByteArray &ba)
//{
//#ifndef QT_NO_COMPRESS
//    return qUncompress(ba);
//#else
//    return ba;
//#endif
//}
//bool QSvgIconEnginePrivate::tryLoad(QSvgRenderer *renderer, QIcon::Mode mode, QIcon::State state)
//{
//    if (svgBuffers) {
//        QByteArray buf = svgBuffers->value(hashKey(mode, state));
//        if (!buf.isEmpty()) {
//            buf = maybeUncompress(buf);
//            renderer->load(buf);
//            return true;
//        }
//    }
//    QString svgFile = svgFiles.value(hashKey(mode, state));
//    if (!svgFile.isEmpty()) {
//        renderer->load(svgFile);
//        return true;
//    }
//    return false;
//}
//QIcon::Mode QSvgIconEnginePrivate::loadDataForModeAndState(QSvgRenderer *renderer, QIcon::Mode mode, QIcon::State state)
//{
//    if (tryLoad(renderer, mode, state))
//        return mode;
//    const QIcon::State oppositeState = (state == QIcon::On) ? QIcon::Off : QIcon::On;
//    if (mode == QIcon::Disabled || mode == QIcon::Selected) {
//        const QIcon::Mode oppositeMode = (mode == QIcon::Disabled) ? QIcon::Selected : QIcon::Disabled;
//        if (tryLoad(renderer, QIcon::Normal, state))
//            return QIcon::Normal;
//        if (tryLoad(renderer, QIcon::Active, state))
//            return QIcon::Active;
//        if (tryLoad(renderer, mode, oppositeState))
//            return mode;
//        if (tryLoad(renderer, QIcon::Normal, oppositeState))
//            return QIcon::Normal;
//        if (tryLoad(renderer, QIcon::Active, oppositeState))
//            return QIcon::Active;
//        if (tryLoad(renderer, oppositeMode, state))
//            return oppositeMode;
//        if (tryLoad(renderer, oppositeMode, oppositeState))
//            return oppositeMode;
//    } else {
//        const QIcon::Mode oppositeMode = (mode == QIcon::Normal) ? QIcon::Active : QIcon::Normal;
//        if (tryLoad(renderer, oppositeMode, state))
//            return oppositeMode;
//        if (tryLoad(renderer, mode, oppositeState))
//            return mode;
//        if (tryLoad(renderer, oppositeMode, oppositeState))
//            return oppositeMode;
//        if (tryLoad(renderer, QIcon::Disabled, state))
//            return QIcon::Disabled;
//        if (tryLoad(renderer, QIcon::Selected, state))
//            return QIcon::Selected;
//        if (tryLoad(renderer, QIcon::Disabled, oppositeState))
//            return QIcon::Disabled;
//        if (tryLoad(renderer, QIcon::Selected, oppositeState))
//            return QIcon::Selected;
//    }
//    return QIcon::Normal;
//}
//QPixmap QSvgIconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state)
//{
//    QPixmap pm;
//    QString pmckey(d->pmcKey(size, mode, state));
//    if (QPixmapCache::find(pmckey, &pm))
//        return pm;
//    if (d->addedPixmaps) {
//        pm = d->addedPixmaps->value(d->hashKey(mode, state));
//        if (!pm.isNull() && pm.size() == size)
//            return pm;
//    }
//    QSvgRenderer renderer;
//    const QIcon::Mode loadmode = d->loadDataForModeAndState(&renderer, mode, state);
//    if (!renderer.isValid())
//        return pm;
//    QSize actualSize = renderer.defaultSize();
//    if (!actualSize.isNull())
//        actualSize.scale(size, Qt::KeepAspectRatio);
//    if (actualSize.isEmpty())
//        return QPixmap();
//    QImage img(actualSize, QImage::Format_ARGB32_Premultiplied);
//    img.fill(0x00000000);
//    QPainter p(&img);
//    renderer.render(&p);
//    p.end();
//    pm = QPixmap::fromImage(img);
//    if (qobject_cast<QGuiApplication *>(QCoreApplication::instance()))
//    {
//        if (loadmode != mode && mode != QIcon::Normal)
//        {
//            const QPixmap generated = QGuiApplicationPrivate::instance()->applyQIconStyleHelper(mode, pm);
//            if (!generated.isNull())
//                pm = generated;
//        }
//    }
//    if (!pm.isNull())
//        QPixmapCache::insert(pmckey, pm);
//    return pm;
//}
//void QSvgIconEngine::addPixmap(const QPixmap &pixmap, QIcon::Mode mode, QIcon::State state)
//{
//    if (!d->addedPixmaps)
//        d->addedPixmaps = new QHash<int, QPixmap>;
//    d->stepSerialNum();
//    d->addedPixmaps->insert(d->hashKey(mode, state), pixmap);
//}
//enum FileType { OtherFile, SvgFile, CompressedSvgFile };
//static FileType fileType(const QFileInfo &fi)
//{
//    const QString &abs = fi.absoluteFilePath();
//    if (abs.endsWith(QLatin1String(".svg"), Qt::CaseInsensitive))
//        return SvgFile;
//    if (abs.endsWith(QLatin1String(".svgz"), Qt::CaseInsensitive)
//        || abs.endsWith(QLatin1String(".svg.gz"), Qt::CaseInsensitive)) {
//        return CompressedSvgFile;
//    }
//#ifndef QT_NO_MIMETYPE
//    const QString &mimeTypeName = QMimeDatabase().mimeTypeForFile(fi).name();
//    if (mimeTypeName == QLatin1String("image/svg+xml"))
//        return SvgFile;
//    if (mimeTypeName == QLatin1String("image/svg+xml-compressed"))
//        return CompressedSvgFile;
//#endif // !QT_NO_MIMETYPE
//    return OtherFile;
//}
//void QSvgIconEngine::addFile(const QString &fileName, const QSize &, QIcon::Mode mode, QIcon::State state)
//{
//    if (!fileName.isEmpty())
//    {
//         const QFileInfo fi(fileName);
//         const QString abs = fi.absoluteFilePath();
//         const FileType type = fileType(fi);
//#ifndef QT_NO_COMPRESS
//         if (type == SvgFile || type == CompressedSvgFile)
//         {
//#else
//         if (type == SvgFile) {
//#endif
//             QSvgRenderer renderer(abs);
//             if (renderer.isValid()) {
//                 d->stepSerialNum();
//                 d->svgFiles.insert(d->hashKey(mode, state), abs);
//             }
//         } else if (type == OtherFile) {
//             QPixmap pm(abs);
//             if (!pm.isNull())
//                 addPixmap(pm, mode, state);
//         }
//    }
//}
//void QSvgIconEngine::paint(QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state)
//{
//    QSize pixmapSize = rect.size();
//    if (painter->device())
//        pixmapSize *= painter->device()->devicePixelRatioF();
//    painter->drawPixmap(rect, pixmap(pixmapSize, mode, state));
//}
//QString QSvgIconEngine::key() const
//{
//    return QLatin1String("svg");
//}
//QIconEngine *QSvgIconEngine::clone() const
//{
//    return new QSvgIconEngine(*this);
//}
//bool QSvgIconEngine::read(QDataStream &in)
//{
//    d = new QSvgIconEnginePrivate;
//    d->svgBuffers = new QHash<int, QByteArray>;
//    if (in.version() >= QDataStream::Qt_4_4) {
//        int isCompressed;
//        QHash<int, QString> fileNames;  // For memoryoptimization later
//        in >> fileNames >> isCompressed >> *d->svgBuffers;
//#ifndef QT_NO_COMPRESS
//        if (!isCompressed) {
//            for (auto it = d->svgBuffers->begin(), end = d->svgBuffers->end(); it != end; ++it)
//                it.value() = qCompress(it.value());
//        }
//#else
//        if (isCompressed) {
//            qWarning("QSvgIconEngine: Can not decompress SVG data");
//            d->svgBuffers->clear();
//        }
//#endif
//        int hasAddedPixmaps;
//        in >> hasAddedPixmaps;
//        if (hasAddedPixmaps) {
//            d->addedPixmaps = new QHash<int, QPixmap>;
//            in >> *d->addedPixmaps;
//        }
//    }
//    else {
//        QPixmap pixmap;
//        QByteArray data;
//        uint mode;
//        uint state;
//        int num_entries;
//        in >> data;
//        if (!data.isEmpty()) {
//#ifndef QT_NO_COMPRESS
//            data = qUncompress(data);
//#endif
//            if (!data.isEmpty())
//                d->svgBuffers->insert(d->hashKey(QIcon::Normal, QIcon::Off), data);
//        }
//        in >> num_entries;
//        for (int i=0; i<num_entries; ++i) {
//            if (in.atEnd())
//                return false;
//            in >> pixmap;
//            in >> mode;
//            in >> state;
//            // The pm list written by 4.3 is buggy and/or useless, so ignore.
//            //addPixmap(pixmap, QIcon::Mode(mode), QIcon::State(state));
//        }
//    }
//    return true;
//}
//bool QSvgIconEngine::write(QDataStream &out) const
//{
//    if (out.version() >= QDataStream::Qt_4_4) {
//        int isCompressed = 0;
//#ifndef QT_NO_COMPRESS
//        isCompressed = 1;
//#endif
//        QHash<int, QByteArray> svgBuffers;
//        if (d->svgBuffers)
//            svgBuffers = *d->svgBuffers;
//        for (auto it = d->svgFiles.cbegin(), end = d->svgFiles.cend(); it != end; ++it) {
//            QByteArray buf;
//            QFile f(it.value());
//            if (f.open(QIODevice::ReadOnly))
//                buf = f.readAll();
//#ifndef QT_NO_COMPRESS
//            buf = qCompress(buf);
//#endif
//            svgBuffers.insert(it.key(), buf);
//        }
//        out << d->svgFiles << isCompressed << svgBuffers;
//        if (d->addedPixmaps)
//            out << (int)1 << *d->addedPixmaps;
//        else
//            out << (int)0;
//    }
//    else {
//        QByteArray buf;
//        if (d->svgBuffers)
//            buf = d->svgBuffers->value(d->hashKey(QIcon::Normal, QIcon::Off));
//        if (buf.isEmpty()) {
//            QString svgFile = d->svgFiles.value(d->hashKey(QIcon::Normal, QIcon::Off));
//            if (!svgFile.isEmpty()) {
//                QFile f(svgFile);
//                if (f.open(QIODevice::ReadOnly))
//                    buf = f.readAll();
//            }
//        }
//#ifndef QT_NO_COMPRESS
//        buf = qCompress(buf);
//#endif
//        out << buf;
//        // 4.3 has buggy handling of added pixmaps, so don't write any
//        out << (int)0;
//    }
//    return true;
//}
//void QSvgIconEngine::virtual_hook(int id, void *data)
//{
//    if (id == QIconEngine::IsNullHook) {
//        *reinterpret_cast<bool*>(data) = d->svgFiles.isEmpty() && !d->addedPixmaps && (!d->svgBuffers || d->svgBuffers->isEmpty());
//    }
//    QIconEngine::virtual_hook(id, data);
//}
//QT_END_NAMESPACE
//#endif // QT_NO_SVGRENDERER
